---
title: Commandes CLI
i18nReady: true
---
import Since from '~/components/Since.astro';
import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
import ReadMore from '~/components/ReadMore.astro'


Vous pouvez utiliser l'interface en ligne de commande (CLI) fournie par Astro pour développer, construire et prévisualiser votre projet à partir d'une fenêtre de terminal.

### Commandes `astro`

Utilisez le CLI en exécutant l'une des **commandes** documentées sur cette page avec votre gestionnaire de paquets préféré, suivie éventuellement de toutes les **options**. Les options personnalisent le comportement d'une commande.

L'une des commandes que vous utiliserez le plus souvent est `astro dev`. Cette commande démarre le serveur de développement et vous donne un aperçu votre site mis à jour en direct dans un navigateur pendant que vous travaillez :

<PackageManagerTabs>
  <Fragment slot="npm">
  ```shell
  # démarre le serveur de développement
  npx astro dev
  ```
  </Fragment>
  <Fragment slot="pnpm">
  ```shell
  # démarre le serveur de développement
  pnpm astro dev
  ```
  </Fragment>
  <Fragment slot="yarn">
  ```shell
  # démarre le serveur de développement
  yarn astro dev
  ```
  </Fragment>
</PackageManagerTabs>

Vous pouvez taper `astro --help` dans votre terminal pour afficher une liste de toutes les commandes disponibles :

<PackageManagerTabs>
  <Fragment slot="npm">
  ```shell
  npx astro --help
  ```
  </Fragment>
  <Fragment slot="pnpm">
  ```shell
  pnpm astro --help
  ```
  </Fragment>
  <Fragment slot="yarn">
  ```shell
  yarn astro --help
  ```
  </Fragment>
</PackageManagerTabs>

Le message suivant s'affichera dans votre terminal :

```bash
astro [commande] [...options]

Commandes
              add  Ajouter une intégration.
            build  Build votre projet et l'écrire sur le disque.
            check  Vérifier votre projet pour les erreurs.
              dev  Démarrer le serveur de développement.
             docs  Ouvrir la documentation dans votre navigateur Web.
             info  Liste d'informations sur votre configuration actuelle d'Astro.
          preview  Prévisualiser votre Build localement.
             sync  Générer les types de collection de contenu.
      preferences  Configurer les préférences de l'utilisateur.
        telemetry  Configurer les paramètres de télémétrie.
        
Options globales
--config <chemin>  Spécifier votre fichier de configuration.
  --root <chemin>  Spécifier le dossier racine de votre projet.
     --site <url>  Spécifier le site de votre projet.
--base <pathname>  Spécifier la base de votre projet.
        --verbose  Activer l'enregistrement détaillé.
         --silent  Désactiver tous les journaux.
        --version  Afficher le numéro de version et quitter.
           --open  Ouvrir l'application dans le navigateur au démarrage du serveur.
           --help  Afficher ce message d'aide.
```

:::note
Le `--` supplémentaire avant chaque option est nécessaire pour que `npm` transmette options à la commande `astro`.
:::

### Scripts `package.json`

Vous pouvez également utiliser des scripts dans `package.json` pour des versions plus courtes de ces commandes. L'utilisation d'un script vous permet d'utiliser les mêmes commandes avec lesquelles vous pourriez être familier dans d'autres projets, telles que `npm run build`.

Pour les commandes `astro` les plus courantes (`astro dev`, `astro build` et `astro preview`), les scripts suivants sont ajoutés automatiquement lorsque vous créez un projet en utilisant [l'assistant d'installation `create astro`](/fr/install/auto/#1-utiliser-lassistant-dinstallation).

Lorsque vous suivez les instructions pour [installer Astro manuellement](/fr/install/manual/#2-installer-astro), vous êtes invité à ajouter vous-même ces scripts. Vous pouvez également ajouter manuellement d'autres scripts à cette liste pour toute commande que vous utilisez fréquemment. 

```json title="package.json"
{
  "scripts": {
    "dev": "astro dev",
    "start": "astro dev",
    "build": "astro build",
    "preview": "astro preview"
  }
}
```

Vous utiliserez souvent ces commandes `astro`, ou les scripts qui les exécutent, sans aucune option. Ajoutez des options à la commande lorsque vous souhaitez personnaliser le comportement de la commande. Par exemple, vous souhaitez peut-être démarrer le serveur de développement sur un port différent ou Build votre site en incluant les pages de brouillon.

<PackageManagerTabs>
  <Fragment slot="npm">
  ```shell
  # lance le serveur de développement sur le port 8080 en utilisant le script `start` dans `package.json`
  npm run start -- --port 8080
    
  # Build votre site en incluant les pages de brouillon en utilisant le script `build` dans `package.json`
  npm run build -- --drafts
  ```
  </Fragment>
  <Fragment slot="pnpm">
  ```shell
  # lance le serveur de développement sur le port 8080 en utilisant le script `start` dans `package.json`
  pnpm start --port 8080
    
  # Build votre site en incluant les pages de brouillon en utilisant le script `build` dans `package.json`
  pnpm build --drafts
  ```
  </Fragment>
  <Fragment slot="yarn">
  ```shell
  # lance le serveur de développement sur le port 8080 en utilisant le script `start` dans `package.json`
  yarn start --port 8080
    
  # Build votre site en incluant les pages de brouillon en utilisant le script `build` dans `package.json`
  yarn build --drafts
  ```
  </Fragment>
</PackageManagerTabs>

{/*

CONTENU ORIGINAL Sur Lequel Nous Pouvons Toujours revenir si le nouveau contenu est trop amical

Vous pouvez utiliser l'interface en ligne de commande (CLI) fournie par Astro pour développer, construire et prévisualiser votre projet à partir d'une fenêtre de terminal.

Utilisez le CLI en exécutant l'une des **commandes** documentées sur cette page, suivie éventuellement de toutes les **options**. Les options personnalisent le comportement d'une commande. Par exemple, pour démarrer le serveur de développement sur le port `8080`, vous combineriez la commande `astro dev` avec l'option `--port` : `astro dev --port 8080`.

Dans la plupart des cas, vous utiliserez le CLI via votre gestionnaire de paquets :

<PackageManagerTabs>
  <Fragment slot="npm">
  ```shell
  npx astro dev --port 8080
  ```
  </Fragment>
  <Fragment slot="pnpm">
  ```shell
  pnpm astro dev --port 8080
  ```
  </Fragment>
  <Fragment slot="yarn">
  ```shell
  yarn astro dev --port 8080
  ```
  </Fragment>
</PackageManagerTabs>

Si vous avez démarré votre projet en utilisant [l'assistant `create astro`](/fr/install/auto/#1-utiliser-lassistant-dinstallation), vous pouvez également utiliser les scripts dans `package.json` pour une version abrégée de ces commandes. Consultez le fichier README.md de votre projet pour savoir quelles commandes sont disponibles.

<PackageManagerTabs>
  <Fragment slot="npm">
  ```shell
  # démarre le serveur de développement sur le port 8080 en utilisant le script `start` dans `package.json`
  npm run start -- --port 8080
  ```
  </Fragment>
  <Fragment slot="pnpm">
  ```shell
  # démarre le serveur de développement sur le port 8080 en utilisant le script `start` dans `package.json`
  pnpm start --port 8080
  ```
  </Fragment>
  <Fragment slot="yarn">
  ```shell
  # démarre le serveur de développement sur le port 8080 en utilisant le script `start` dans `package.json`
  yarn start --port 8080
  ```
  </Fragment>
</PackageManagerTabs>

*/}

## `astro dev`

Lance le serveur de développement d'Astro. Il s'agit d'un serveur HTTP local qui ne regroupe pas les fichiers et les ressources. Il utilise le Remplacement de Modules à Chaud (HMR) pour mettre à jour votre navigateur lorsque vous enregistrez des modifications dans votre éditeur.

## `astro build`

Compile votre site pour le déploiement. Par défaut, cela générera des fichiers statiques et les placera dans un répertoire `dist/`. Si le [SSR est activé](/fr/guides/server-side-rendering/), cela générera les fichiers serveur nécessaires à votre site.

Peut être combiné avec les [options courantes](#options-courantes) documentées ci-dessous.

## `astro preview`

Démarre un serveur local pour servir votre répertoire statique `dist/`.

Cette commande est utile pour prévisualiser votre Build localement avant de le déployer. Elle n'est pas conçue pour être exécutée en production. Pour obtenir de l'aide sur l'hébergement en production, consultez notre guide sur [Déployer un site Astro](/fr/guides/deploy/).

Depuis Astro 1.5.0, `astro preview` fonctionne également pour les Builds SSR si vous utilisez un adaptateur qui le supporte. Actuellement, seul [l'adaptateur Node](/fr/guides/integrations-guide/node/) prend en charge `astro preview`.

Peut être combiné avec les [options courantes](#options-courantes) documentées ci-dessous.

## `astro check`

Lance les diagnostics (comme la vérification de type dans les fichiers `.astro`) sur votre projet et signale les erreurs à la console. Si des erreurs sont trouvées, le processus se terminera avec un code de **1**.

Cette commande est destinée à être utilisée dans un processus d'intégration continue.

<h3>Options</h3>

Utilisez ces options pour personnaliser le comportement d'une commande.

#### `--watch`

La commande surveillera toute modification apportée aux fichiers `.astro` et signalera toute erreur.

<ReadMore>En savoir plus sur le [support de TypeScript dans Astro](/fr/guides/typescript/).</ReadMore>

## `astro sync`

<p><Since v="2.0.0" /></p>

:::tip
Exécuter `astro dev`, `astro build` ou `astro check` exécutera également la commande `sync`.
:::

Génère des types TypeScript pour tous les modules Astro. Cela configure un [fichier `src/env.d.ts`](/fr/guides/typescript/#configuration) pour l'inférence de type et définit le module `astro:content` pour [l'API de Collections de Contenu](/fr/guides/content-collections/).

## `astro add`

Ajoute une intégration à votre configuration. En savoir plus dans [le guide des intégrations](/fr/guides/integrations-guide/#configuration-automatique-des-intégrations).

## `astro docs`

Lance directement le site web Astro Docs depuis le terminal.

## `astro info`

Rapporte des informations utiles sur votre environnement Astro actuel. Utile pour fournir des informations lors de l'ouverture d'un problème.

```shell
astro info
```

Exemple de sortie:

```
Astro                    v3.0.12
Node                     v20.5.1
System                   macOS (arm64)
Package Manager          pnpm
Output                   server
Adapter                  @astrojs/vercel/serverless
Integrations             none
```

## `astro preferences`

Gérer les préférences des utilisateurs avec la commande `astro preferences`. Les préférences utilisateur sont spécifiques à chaque utilisateur d'Astro, contrairement au fichier `astro.config.mjs` qui modifie le comportement de toutes les personnes travaillant sur un projet.

Par défaut, les préférences de l'utilisateur sont limitées au projet en cours, et sont stockées dans un fichier local `.astro/settings.json`..

En utilisant l'option `--global`, les préférences utilisateur peuvent aussi être appliquées à tous les projets Astro sur la machine courante. Les préférences utilisateur globales sont stockées dans un emplacement spécifique au système d'exploitation.

Par exemple, pour désactiver la devToolbar dans un projet Astro spécifique :

```shell
astro preferences disable devToolbar
```

Pour désactiver la devToolbar dans tous les projets Astro sur la machine actuelle :

```shell
astro preferences disable --global devToolbar
```

La devToolbar peut ensuite être activée avec :

```shell
astro preferences enable devToolbar
```

La commande `reset` réinitialise une préférence à sa valeur par défaut :

```shell
astro preferences reset devToolbar
```

La commande `list` affiche les paramètres actuels de toutes les préférences utilisateur configurables. Elle supporte également une sortie `--json` lisible par la machine.

```shell
astro preferences list
```

## `astro telemetry`

Configure la télémétrie pour l'utilisateur actuel du CLI. La télémétrie est une donnée anonyme qui fournit à l'équipe Astro des informations sur les fonctionnalités Astro les plus souvent utilisées. Pour en savoir plus, voir la [page télémetrie d'Astro'](https://astro.build/telemetry/).

La télémétrie peut être désactivée avec cette commande CLI :

```shell
astro telemetry disable
```

La télémétrie peut être réactivée ultérieurement avec :

```shell
astro telemetry enable
```

La commande `reset` réinitialise les données de télémétrie :

```shell
astro telemetry reset
```

:::tip[Vous souhaitez désactiver la télémétrie dans les environnements IC ?]
Ajoutez la commande `astro telemetry disable` à vos scripts IC ou définissez la variable d'environnement `ASTRO_TELEMETRY_DISABLED`.
:::

## Options courantes

### `--root <chemin>`

Spécifie le chemin de la racine du projet. Si aucun chemin n'est spécifié, le répertoire de travail actuel est considéré comme la racine.

La racine est utilisée pour trouver le fichier de configuration Astro.

```shell
astro --root monDossierRacine/monDossierProjet dev
```

### `--config <chemin>`

Spécifie le chemin du fichier de configuration par rapport à la racine du projet. Il est défini par défaut à `astro.config.mjs`. Utilisez cette option si vous utilisez un nom différent pour votre fichier de configuration ou si votre fichier de configuration est dans un autre dossier.

```shell
astro --config config/astro.config.mjs dev
```

### `--outDir <chemin>`

<p><Since v="3.3.0" /></p>

Configure le [`outDir`](/fr/reference/configuration-reference/#outdir) pour votre projet. Passer cette option remplacera la valeur de `outDir` dans votre fichier `astro.config.mjs`, s'il en existe un.

### `--site <url>`

Configure le [`site`](/fr/reference/configuration-reference/#site) pour votre projet. Utiliser cette option remplacera, si elle existe, la valeur `site` de votre fichier `astro.config.mjs`.

### `--base <chemin>`

<p><Since v="1.4.1" /></p>

Configure la [`base`](/fr/reference/configuration-reference/#base) de votre projet. Utiliser cette option remplacera, si elle existe, la valeur `base` de votre fichier `astro.config.mjs`.

### `--port <number>`

Spécifie le port sur lequel le serveur de développement et le serveur de prévisualisation doivent être exécutés. La valeur par défaut est `4321`.

### `--host [adresse d'hôte optionnelle]`

Définit les adresses IP du réseau sur lesquelles le serveur de développement et le serveur de prévisualisation doivent écouter (c.-à-d. les adresses IP non locales). Cela peut être utile pour tester votre projet sur des appareils locaux comme un téléphone portable pendant le développement.

- `--host` — écoute sur toutes les adresses, y compris les adresses LAN et publiques
- `--host <adresse personnalisée>` - écoute sur une adresse IP du réseau à `<adresse personnalisée>`.

:::caution
N'utilisez pas l'option `--host` pour exposer le serveur de développement et le serveur de prévisualisation dans un environnement de production. Ces serveurs sont conçus pour une utilisation locale lors du développement de votre site uniquement.
:::

### `--verbose`

Active les journaux verbeux, ce qui est utile pour déboguer un problème.

### `--silent`

Active les journaux silencieux, ce qui lance le serveur sans aucune sortie dans la console.

## Options globales

Utilisez ces options pour obtenir des informations à propos du CLI `astro`.

### `--version`

Affiche le numéro de version d'Astro et quitte.

### `--open`

Ouvre automatiquement l'application dans le navigateur au démarrage du serveur.

### `--help`

Affiche le message d'aide et quitte.

## API avancées (expérimentales)

Si vous avez besoin de plus de contrôle lors de l'exécution d'Astro, le paquet `"astro"` exporte également des API pour exécuter par programme les commandes CLI.

Ces API sont expérimentales et leur signature peuvent changer. Toute mise à jour sera mentionnée dans le [Astro changelog](https://github.com/withastro/astro/blob/main/packages/astro/CHANGELOG.md) et les informations ci-dessous montreront toujours les informations actuelles et à jour.

### `AstroInlineConfig`

Le type `AstroInlineConfig` est utilisé par toutes les API de commande ci-dessous. Il s'étend à partir du type utilisateur [Astro config](/fr/reference/configuration-reference/) :

```ts
interface AstroInlineConfig extends AstroUserConfig {
	configFile?: string | false;
	mode?: "development" | "production";
	logLevel?: "debug" | "info" | "warn" | "error" | "silent";
}
```

#### `configFile`

<p>

**Type:** `string | false`<br />
**Défaut:** `undefined`
</p>

Un chemin personnalisé vers le fichier de configuration d'Astro.

Si cette valeur est indéfinie (par défaut) ou non définie, Astro recherchera un fichier `astro.config.(js,mjs,ts)` relatif à la `root` et chargera le fichier de configuration s'il est trouvé.

Si un chemin relatif est défini, il sera résolu en fonction du répertoire de travail courant.

Mettre `false` pour désactiver le chargement de tout fichier de configuration.

La configuration en ligne passée dans cet objet sera prioritaire lors de la fusion avec la configuration utilisateur chargée.

#### `mode`

<p>

**Type:** `"development" | "production"`<br />
**Défaut:** `"development"` lors de l'exécution de `astro dev`, `"production"` lors de l'exécution de `astro build`
</p>

Le mode utilisé lors de la construction de votre site pour générer du code "developpement" ou "production".

#### `logLevel`

<p>

**Type:** `"debug" | "info" | "warn" | "error" | "silent"`<br />
**Défaut:** `"info"`
</p>

Le niveau de journalisation pour filtrer les messages enregistrés par Astro.

- `"debug"`: Enregistre tout, y compris les diagnostics de débogage.
- `"info"`: Enregistre les messages d'information, les avertissements et les erreurs.
- `"warn"`: Enregistre les avertissements et les erreurs.
- `"error"`: Ne consigne que les erreurs.
- `"silent"`: Pas de journalisation.

### `dev()`

**Type:** `(inlineConfig: AstroInlineConfig) => AstroDevServer`

Similaire à [`astro dev`](#astro-dev), il fait tourner le serveur de développement d'Astro.

```js
import { dev } from "astro";

const devServer = await dev({
  root: "./my-project",
});

// Arrêter le serveur si nécessaire
await devServer.stop();
```

### `build()`

**Type:** `(inlineConfig: AstroInlineConfig) => void`

Similaire à [`astro build`](#astro-build), il construit votre site pour le deploiement.

```js
import { build } from "astro";

await build({
  root: "./my-project",
});
```

### `preview()`

**Type:** `(inlineConfig: AstroInlineConfig) => AstroPreviewServer`

Similaire à [`astro preview`](#astro-preview), il démarre un serveur local pour servir votre répertoire statique `dist/`.

```js
import { preview } from "astro";

const previewServer = await preview({
  root: "./my-project",
});

// Arrêter le serveur si besoin
await previewServer.stop();
```

### `sync()`

**Type:** `(inlineConfig: AstroInlineConfig) => number`

Similaire à [`astro sync`](#astro-sync), il génère des types TypeScript pour tous les modules Astro.

```js
import { sync } from "astro";

const exitCode = await sync({
  root: "./my-project",
});

process.exit(exitCode)
```
